{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "try:\n",
    "   del X_train, y_train\n",
    "   del X_test, y_test\n",
    "   print('Clear previously loaded data.')\n",
    "except:\n",
    "   pass\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.328008\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "**Your answer:** \n",
    "\n",
    "初始权重W很小，所以输出的scores在类别的10个维度中几乎都接近0，$softmax=\\frac{e^{s_{y_i}}}{\\sum_j e^{s_j}}$，所示分子为1，分母为10，损失函数为$L_i=-log(\\frac{e^{s_{y_i}}}{\\sum_j e^{s_j}})$，所以初始的损失函数为-log(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -2.514879 analytic: -2.514879, relative error: 9.131714e-09\n",
      "numerical: 1.146463 analytic: 1.146463, relative error: 6.045798e-08\n",
      "numerical: 0.922033 analytic: 0.922033, relative error: 6.873744e-08\n",
      "numerical: -1.024691 analytic: -1.024691, relative error: 8.767664e-09\n",
      "numerical: 4.025035 analytic: 4.025035, relative error: 5.782734e-09\n",
      "numerical: -0.192001 analytic: -0.192001, relative error: 1.534854e-07\n",
      "numerical: 2.544338 analytic: 2.544338, relative error: 3.835357e-08\n",
      "numerical: -0.166684 analytic: -0.166684, relative error: 2.263914e-07\n",
      "numerical: 1.290129 analytic: 1.290129, relative error: 2.901122e-08\n",
      "numerical: -0.277438 analytic: -0.277438, relative error: 4.447571e-08\n",
      "numerical: -1.080547 analytic: -1.080547, relative error: 8.092007e-09\n",
      "numerical: -0.328729 analytic: -0.328729, relative error: 7.166870e-09\n",
      "numerical: -0.442546 analytic: -0.442546, relative error: 2.770016e-08\n",
      "numerical: 0.293512 analytic: 0.293512, relative error: 6.004730e-08\n",
      "numerical: 0.187510 analytic: 0.187510, relative error: 2.958895e-07\n",
      "numerical: -0.494454 analytic: -0.494454, relative error: 2.242058e-08\n",
      "numerical: 0.655176 analytic: 0.655176, relative error: 6.866488e-08\n",
      "numerical: -1.226778 analytic: -1.226778, relative error: 2.108380e-08\n",
      "numerical: -1.783044 analytic: -1.783044, relative error: 2.836760e-08\n",
      "numerical: 3.441579 analytic: 3.441579, relative error: 2.645342e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.328008e+00 computed in 0.136329s\n",
      "vectorized loss: 2.328008e+00 computed in 0.006018s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.352163 val accuracy: 0.368000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.330449 val accuracy: 0.346000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.344102 val accuracy: 0.354000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.332408 val accuracy: 0.352000\n",
      "best validation accuracy achieved during cross-validation: 0.368000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax = Softmax()         # 创建softmax分类器\n",
    "        softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=2000,\n",
    "                     batch_size=200, verbose=False)\n",
    "        pred = lambda x: softmax.predict(x)\n",
    "        pred_train, pred_val = map(pred, (X_train, X_val))\n",
    "        train_acc = np.mean(pred_train == y_train)\n",
    "        val_acc = np.mean(pred_val == y_val)\n",
    "        results[(lr, reg)] = (train_acc, val_acc)\n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_softmax = softmax\n",
    "            \n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.362000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inline Question** - *True or False*\n",
    "\n",
    "It's possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "*Your answer*: yes\n",
    "\n",
    "*Your explanation*:\n",
    "\n",
    "在SVM分类器中，只要正确分类大于错误分类数一个安全的边界margin就行，所以在该分类器中，稍微改变样本，只要分类差值仍旧在安全边界内即可，但softmax不同，该分类器总是使分类正确的分数不断变大，分类错误的分数不断减小，所以改变样本后，softmax会有所改变"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x18683b29cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:]    # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
